{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 3:  Implement SLAM - \"extra credit\"\n",
    "\n",
    "---\n",
    "\n",
    "## Project Overview\n",
    "\n",
    "This addition to the project implements a suggestion in the rubric, to only consider the most recent pose. My attempt will be assisted by the concepts Sebastian Thrun conveys in this youtube video about \"Online SLAM\", in which this precise topic is taken up: https://www.youtube.com/watch?v=jaeNlxhQL1I. Other changes:\n",
    "1. MyOnlineSlam is now implemented as a class\n",
    "1. The data loop happens outside of the class.\n",
    "1. The x and y xi vectors are separated. Omega is the same for both.\n",
    "\n",
    "I will also be attempting to make a short video of the movements of the robot. For plotting purposes I have to use a modified version of \"make_data\" because the robot's ground truth position was not being saved anywhere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the world\n",
    "\n",
    "In my world, the number of landmarks increases to ten, the robot doesn't move as far in each step and can't sense as far; therefore the number of time steps increases in order to be able to cover most of the world space.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from helpers import check_for_data\n",
    "\n",
    "# your implementation of slam should work with the following inputs\n",
    "# feel free to change these input values and see how it responds!\n",
    "\n",
    "# world parameters\n",
    "num_landmarks      = 10       # number of landmarks\n",
    "N                  = 100      # time steps\n",
    "world_size         = 100.0    # size of world (square)\n",
    "\n",
    "# robot parameters\n",
    "measurement_range  = 30.0     # range at which we can sense landmarks\n",
    "motion_noise       = 2.0      # noise in robot motion\n",
    "measurement_noise  = 2.0      # noise in the measurements\n",
    "distance           = 10.0     # distance by which robot (intends to) move each iteratation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[88, 13], [67, 23], [43, 67], [21, 13], [70, 39], [91, 56], [96, 95], [10, 84], [99, 86], [32, 2]]\n",
      "Robot: [x=67.64845 y=14.58713]\n"
     ]
    }
   ],
   "source": [
    "from robot_class import robot\n",
    "import random\n",
    "from math import *\n",
    "\n",
    "# --------\n",
    "# this routine makes the robot data\n",
    "# the data is a list of measurements and movements: [measurements, [dx, dy]]\n",
    "# collected over a specified number of time steps, N\n",
    "#\n",
    "def my_make_data(N, num_landmarks, world_size, measurement_range, motion_noise, \n",
    "                 measurement_noise, distance):\n",
    "    pass\n",
    "\n",
    "    # check that data has been made\n",
    "    try:\n",
    "        check_for_data(num_landmarks, world_size, measurement_range, motion_noise, measurement_noise)\n",
    "    except ValueError:\n",
    "        print('Error: You must implement the sense function in robot_class.py.')\n",
    "        return []\n",
    "    \n",
    "    complete = False\n",
    "    \n",
    "    r = robot(world_size, measurement_range, motion_noise, measurement_noise)\n",
    "    r.make_landmarks(num_landmarks)\n",
    "\n",
    "    while not complete:\n",
    "\n",
    "        data = []\n",
    "\n",
    "        seen = [False for row in range(num_landmarks)]\n",
    "    \n",
    "        # guess an initial motion\n",
    "        orientation = random.random() * 2.0 * pi\n",
    "        dx = cos(orientation) * distance\n",
    "        dy = sin(orientation) * distance\n",
    "            \n",
    "        for k in range(N-1):\n",
    "    \n",
    "            # collect sensor measurements in a list, Z\n",
    "            Z = r.sense()\n",
    "\n",
    "            # check off all landmarks that were observed \n",
    "            for i in range(len(Z)):\n",
    "                seen[Z[i][0]] = True\n",
    "    \n",
    "            # move\n",
    "            while not r.move(dx, dy):\n",
    "                # if we'd be leaving the robot world, pick instead a new direction\n",
    "                orientation = random.random() * 2.0 * pi\n",
    "                dx = cos(orientation) * distance\n",
    "                dy = sin(orientation) * distance\n",
    "\n",
    "            # collect/memorize all sensor and motion data\n",
    "            # UPDATE: ADD GROUND TRUTH POSITION FOR PLOTTING PURPOSES\n",
    "            #\n",
    "            data.append([Z, [dx, dy], [r.x, r.y]])\n",
    "\n",
    "        # we are done when all landmarks were observed; otherwise re-run\n",
    "        complete = (sum(seen) == num_landmarks)\n",
    "\n",
    "    print(' ')\n",
    "    print('Landmarks: ', r.landmarks)\n",
    "    print(r)\n",
    "\n",
    "\n",
    "    return data, r.landmarks\n",
    "\n",
    "# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\n",
    "data, gt_landmarks = my_make_data(N, num_landmarks, world_size, measurement_range, motion_noise, measurement_noise, distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[6, -23.430945649015158, -17.776464278716304], [8, -24.12364917479613, 3.1955335627616783]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [-7.437925720922407, -6.6841050986681]\n"
     ]
    }
   ],
   "source": [
    "# print out some stats about the data\n",
    "time_step = 0\n",
    "\n",
    "print('Example measurements: \\n', data[time_step][0])\n",
    "print('\\n')\n",
    "print('Example motion: \\n', data[time_step][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class MyOnlineSLAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyOnlineSLAM(object):\n",
    "    def __init__(self,num_landmarks, world_size, motion_noise, measurement_noise):\n",
    "        self.size = 1+num_landmarks\n",
    "        \n",
    "        self.omega = np.zeros((self.size,self.size)) # same for x and y\n",
    "        self.omega[0,0] = 1  # initial location constraint\n",
    "\n",
    "        self.xi_x = np.zeros((self.size))\n",
    "        self.xi_y = np.zeros((self.size))\n",
    "        self.xi_x[0] = self.xi_y[0] = world_size/2 # init location constraint\n",
    "        \n",
    "        # weights for omega/xi\n",
    "        self.Wms = 1.0/measurement_noise\n",
    "        self.Wmo = 1.0/motion_noise\n",
    "        \n",
    "        self.verbose = False\n",
    "        \n",
    "        np.set_printoptions(precision=2, suppress=True, linewidth=128)\n",
    "\n",
    "    def update_ms(self, measurements):\n",
    "        for m in measurements:\n",
    "            lm_j, lm_dx, lm_dy = m[0], m[1], m[2]\n",
    "            lm_j = 1 + lm_j\n",
    "            \n",
    "            self.omega[0,0]       += self.Wms   # 0.x <-> 0.x\n",
    "            self.omega[0,lm_j]    -= self.Wms   # 0.x <-> lm_j.x\n",
    "            self.omega[lm_j,0]    -= self.Wms   # lm_j.x <-> 0.x\n",
    "            self.omega[lm_j,lm_j] += self.Wms   # lm_j.x <-> lm_j.x\n",
    "            \n",
    "            self.xi_x[0]          -= lm_dx*self.Wms\n",
    "            self.xi_y[0]          -= lm_dy*self.Wms\n",
    "            self.xi_x[lm_j]       += lm_dx*self.Wms\n",
    "            self.xi_y[lm_j]       += lm_dy*self.Wms\n",
    "\n",
    "    def update_mo(self, motion):\n",
    "        ## This suddenly got complicated. \n",
    "        ##    -- see https://www.youtube.com/watch?v=jaeNlxhQL1I\n",
    "        ## 1. \"Expand\" omega and xi's by 1 in rows and cols representing new pose\n",
    "        ## 2. Perform motion update\n",
    "        ## 3. Fold old pose information into the new omega and xi's\n",
    "        ## 4. Shrink omega and xi's back to their original sizes by eliminating old pose.\n",
    "        ##\n",
    "        if self.verbose:\n",
    "            print (\"----------------- MOTION UPDATE: \")\n",
    "            print (\"({0:.3f},{1:.3f})\".format(motion[0],motion[1]))\n",
    "        \n",
    "        last = self.size\n",
    "        new_omega                    = np.zeros((last+1,last+1))\n",
    "        new_omega[2:last+1,2:last+1] = self.omega[1:last,1:last].copy()\n",
    "        new_omega[0,2:last+1]        = self.omega[0,1:last].copy()   # first row moves up\n",
    "        new_omega[2:last+1,0]        = self.omega[1:last,0].copy()   # first col moves left\n",
    "        new_omega[0,0]               = self.omega[0,0]               # upper left corner\n",
    "        \n",
    "        if self.verbose:\n",
    "            print (\"----------------- Copied self to new\")\n",
    "            print (\"self.omega: \")\n",
    "            print (self.omega)\n",
    "            print (\"new_omega: \")\n",
    "            print (new_omega)\n",
    "        \n",
    "        # zeroed row and col 1 now ready for new pose, perform update\n",
    "        new_omega[0,0] += self.Wmo   # t.x\n",
    "        new_omega[1,1] += self.Wmo   # t+1.x\n",
    "        new_omega[0,1] -= self.Wmo   # t.x <-> t+1.x\n",
    "        new_omega[1,0] -= self.Wmo   # t+1.x <-> t.x\n",
    "        \n",
    "        # same for xi:\n",
    "        new_xi_x           = np.zeros((last+1))\n",
    "        new_xi_y           = np.zeros((last+1))\n",
    "        new_xi_x[2:last+1] = self.xi_x[1:last].copy()\n",
    "        new_xi_y[2:last+1] = self.xi_y[1:last].copy()\n",
    "        new_xi_x[0]        = self.xi_x[0]\n",
    "        new_xi_y[0]        = self.xi_y[0]\n",
    "        \n",
    "        if self.verbose:\n",
    "            print (\"----------------- created new xi's\")\n",
    "            print (\"self.xi_x: \", self.xi_x)\n",
    "            print (\"new_xi_x : \", new_xi_x)\n",
    "            print (\"self.xi_y: \", self.xi_y)\n",
    "            print (\"new_xi_y : \", new_xi_y)\n",
    "        \n",
    "        new_xi_x[0] -= self.Wmo * motion[0]\n",
    "        new_xi_x[1] += self.Wmo * motion[0]\n",
    "\n",
    "        new_xi_y[0] -= self.Wmo * motion[1]\n",
    "        new_xi_y[1] += self.Wmo * motion[1]\n",
    "        \n",
    "        if self.verbose:\n",
    "            print (\"----------------- After motion update\")\n",
    "            print (\"new_omega:\")\n",
    "            print (new_omega)\n",
    "            print (\"new_xi_x: \", new_xi_x)\n",
    "            print (\"new_xi_y: \", new_xi_y)\n",
    "\n",
    "        # Shrinking omega and xi's back\n",
    "        self.omega = new_omega[1:last+1,1:last+1].copy()\n",
    "        self.xi_x  = new_xi_x[1:last+1].copy()\n",
    "        self.xi_y  = new_xi_y[1:last+1].copy()\n",
    "        \n",
    "        # Now form A, B, and C from old pose info\n",
    "        A   = new_omega[0,1:last+1].copy().reshape(1,-1) # row vector\n",
    "        B   = new_omega[0,0]\n",
    "        C_x = new_xi_x[0]\n",
    "        C_y = new_xi_y[0]\n",
    "\n",
    "        if self.verbose:\n",
    "            print (\"----------------- New back to self, A, B, C's\")\n",
    "            print (\"from new:\")\n",
    "            print (new_omega)\n",
    "            print (\"to self:\")\n",
    "            print (self.omega)\n",
    "            print (\"A: \")\n",
    "            print (A)\n",
    "            print (\"B: \", B)\n",
    "            print (\"new_xi_x : \", new_xi_x)\n",
    "            print (\"self.xi_x: \", self.xi_x)\n",
    "            print (\"C_x : \", C_x)\n",
    "            print (\"new_xi_y : \", new_xi_y)\n",
    "            print (\"self.xi_y: \", self.xi_y)\n",
    "            print (\"C_y : \", C_y)\n",
    "        \n",
    "        AtBinv    = A.T/B\n",
    "        AtBinvA   = np.dot(AtBinv,A)\n",
    "        AtBinvC_x = C_x*AtBinv\n",
    "        AtBinvC_y = C_y*AtBinv\n",
    "\n",
    "        if self.verbose:\n",
    "            print (\"-----------------\")\n",
    "            print (\"AtBinv:\")\n",
    "            print (AtBinv)\n",
    "            print (\"AtBinvA: \")\n",
    "            print (AtBinvA)\n",
    "            print (\"AtBinvC_x: \")\n",
    "            print (AtBinvC_x)\n",
    "            print (\"AtBinvC_y: \")\n",
    "            print (AtBinvC_y)\n",
    "        \n",
    "        # Folding old pose info back into omega/xi\n",
    "        self.omega  -= AtBinvA\n",
    "        self.xi_x   -= np.squeeze(AtBinvC_x)\n",
    "        self.xi_y   -= np.squeeze(AtBinvC_y)\n",
    "\n",
    "        if self.verbose:\n",
    "            print (\"----------------- After folding\")\n",
    "            print (\"omega:\")\n",
    "            print (self.omega)\n",
    "            print (\"xi_x: \", self.xi_x)\n",
    "            print (\"xi_y: \", self.xi_y)\n",
    "        \n",
    "    def __call__(self,measurements, motion):\n",
    "        \n",
    "        self.update_ms(measurements)\n",
    "        self.update_mo(motion)\n",
    "        \n",
    "    def get_mu(self):\n",
    "        ## Compute the best estimate of current pose and landmarks at each time step\n",
    "        ## using the formula, omega_inverse * Xi\n",
    "        try:\n",
    "            omega_inv = np.linalg.inv(self.omega)\n",
    "        except np.linalg.LinAlgError as err:\n",
    "            return None\n",
    "        \n",
    "        mu_x, mu_y = np.dot(omega_inv, self.xi_x), np.dot(omega_inv, self.xi_y)\n",
    "        mu = np.concatenate((mu_x.reshape(-1,1),\n",
    "                             mu_y.reshape(-1,1)), axis=1)\n",
    "        \n",
    "        if self.verbose:\n",
    "            print (\"----------------- Calc mu\")\n",
    "            print (\"omega:\")\n",
    "            print (self.omega)\n",
    "            print (\"omega_inv:\")\n",
    "            print (omega_inv)\n",
    "            print (\"xi_x: \", self.xi_x)\n",
    "            print (\"xi_y: \", self.xi_y)\n",
    "            print (\"mu_x: \", mu_x)\n",
    "            print (\"mu_y: \", mu_y)\n",
    "\n",
    "        return mu\n",
    "\n",
    "    def get_omega_xi(self):\n",
    "        xi = np.concatenate((self.xi_x.reshape(-1,1),\n",
    "                             self.xi_y.reshape(-1,1)), axis=1)\n",
    "        return self.omega, xi\n",
    "\n",
    "myslam = MyOnlineSLAM(num_landmarks, world_size, motion_noise, measurement_noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that your implementation of SLAM works for various inputs, we have provided two helper functions that will help display the estimated pose and landmark locations that your function has produced. First, given a result `mu` and number of time steps, `N`, we define a function that extracts the poses and landmarks locations and returns those as their own, separate lists. \n",
    "\n",
    "Then, we define a function that nicely print out these lists; both of these we will call, in the next step.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a helper function that returns the last pose and a list of landmarks for ease of printing\n",
    "def get_pose_landmarks(mu):\n",
    "    pose = mu[0]\n",
    "    landmarks = mu[1:]\n",
    "    return pose, landmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(lastpose, landmarks):\n",
    "    print('\\n')\n",
    "    print('Estimated Last Pose:')\n",
    "    print(lastpose)\n",
    "    print('\\n')\n",
    "    print('Estimated Landmarks:')\n",
    "    for i in range(len(landmarks)):\n",
    "        print(landmarks[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.patches import ConnectionPatch\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Have to modify display_world for this notebook\n",
    "# from helpers import display_world\n",
    "\n",
    "def my_display_world(world_size, \n",
    "                     gtpose, gtlms,            # ground truth positions\n",
    "                     measpose=None, measlms=None,  # measured positions\n",
    "                     measurements=None,\n",
    "                     save_file=False):\n",
    "    \n",
    "    global plt\n",
    "    global count\n",
    "    \n",
    "    # using seaborn, set background grid to gray\n",
    "    sns.set_style(\"dark\")\n",
    "\n",
    "    # Plot grid of values\n",
    "    world_grid = np.zeros((world_size+1, world_size+1))\n",
    "\n",
    "    # Set minor axes in between the labels\n",
    "    #import matplotlib.pyplot as plt\n",
    "    fig = plt.figure()\n",
    "    ax = plt.gca()\n",
    "    cols = world_size+1\n",
    "    rows = world_size+1\n",
    "\n",
    "    ax.set_xticks([x for x in range(1,cols)],minor=True )\n",
    "    ax.set_yticks([y for y in range(1,rows)],minor=True)\n",
    "    \n",
    "    # Plot grid on minor axes in gray (width = 1)\n",
    "    plt.grid(which='minor',ls='-',lw=1, color='white')\n",
    "    \n",
    "    # Plot grid on major axes in larger width\n",
    "    plt.grid(which='major',ls='-',lw=2, color='white')\n",
    "\n",
    "    # Create an 'o' character that represents the robot\n",
    "    # ha = horizontal alignment, va = vertical\n",
    "    ax.text(gtpose[0], gtpose[1], 'o', ha='center', va='center', color='purple', fontsize=30)\n",
    "\n",
    "    if (measpose is not None):\n",
    "        ax.text(measpose[0], measpose[1], 'o', ha='center', va='center', color='r', fontsize=30)\n",
    "\n",
    "    circle = plt.Circle(gtpose, measurement_range, color='r', alpha=0.1)\n",
    "\n",
    "    ax.add_artist(circle)\n",
    "\n",
    "    # Draw ground truth landmarks if they exists\n",
    "    if(gtlms is not None):\n",
    "        for pos in gtlms:\n",
    "            ax.text(pos[0], pos[1], 'x', ha='center', va='center', color='purple', fontsize=20)\n",
    "    \n",
    "    # Draw landmark estimates if they exists\n",
    "    if(measlms is not None):\n",
    "        for pos in measlms:\n",
    "            ax.text(pos[0], pos[1], 'x', ha='center', va='center', color='red', fontsize=20)\n",
    "\n",
    "    # Draw measurements as lines radiating from the ground truth position\n",
    "    if(measurements is not None):\n",
    "        for m in measurements:\n",
    "            lm_j, lm_dx, lm_dy = m[0], m[1], m[2]\n",
    "            if measlms is not None:\n",
    "                pos = measlms[lm_j]\n",
    "            else:\n",
    "                pos = np.array(gtpose) + np.array([lm_dx, lm_dy])\n",
    "            con = ConnectionPatch(gtpose, pos, \"data\",color=\"r\")\n",
    "            ax.add_artist(con)\n",
    "\n",
    "    # Display final result\n",
    "    if save_file:\n",
    "        fig.savefig('image{0:02d}.png'.format(count), bbox_inches='tight')\n",
    "        count = count + 1\n",
    "        plt.close(fig)\n",
    "    else:\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run SLAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Last Pose:\n",
      "[ 68.84  14.44]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[ 88.68  13.31]\n",
      "[ 67.05  23.53]\n",
      "[ 43.88  68.06]\n",
      "[ 21.14  14.55]\n",
      "[ 70.32  39.91]\n",
      "[ 90.67  57.  ]\n",
      "[ 96.14  96.21]\n",
      "[ 10.98  84.08]\n",
      "[ 98.46  87.31]\n",
      "[ 32.14   3.86]\n"
     ]
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20,20)\n",
    "\n",
    "count = 0\n",
    "\n",
    "myslam = MyOnlineSLAM(num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "gtpose = [world_size/2, world_size/2]\n",
    "\n",
    "# Save initial position\n",
    "my_display_world(int(world_size), gtpose, gt_landmarks,save_file=True)\n",
    "\n",
    "# call your implementation of slam, passing in the necessary parameters\n",
    "for sample in data:\n",
    "    measurements, motion, gtpose = sample\n",
    "    myslam(measurements, motion)\n",
    "    mu = myslam.get_mu()\n",
    "    if(mu is not None):\n",
    "        measpose, measlms = get_pose_landmarks(mu)\n",
    "        my_display_world(int(world_size), gtpose, gt_landmarks, \n",
    "                         measpose, measlms, measurements, save_file=True)\n",
    "    else:\n",
    "        my_display_world(int(world_size), gtpose, gt_landmarks,\n",
    "                         measurements=measurements, save_file=True)\n",
    "\n",
    "# print out the resulting landmarks and poses\n",
    "if(mu is not None):\n",
    "    # get the lists of poses and landmarks\n",
    "    # and print them out\n",
    "    lastpose, landmarks = get_pose_landmarks(mu)\n",
    "    print_all(lastpose, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  adding: image00.png (deflated 32%)\n",
      "  adding: image01.png (deflated 19%)\n",
      "  adding: image02.png (deflated 22%)\n",
      "  adding: image03.png (deflated 25%)\n",
      "  adding: image04.png (deflated 30%)\n",
      "  adding: image05.png (deflated 32%)\n",
      "  adding: image06.png (deflated 31%)\n",
      "  adding: image07.png (deflated 28%)\n",
      "  adding: image08.png (deflated 24%)\n",
      "  adding: image09.png (deflated 23%)\n",
      "  adding: image10.png (deflated 23%)\n",
      "  adding: image11.png (deflated 24%)\n",
      "  adding: image12.png (deflated 25%)\n",
      "  adding: image13.png (deflated 27%)\n",
      "  adding: image14.png (deflated 31%)\n",
      "  adding: image15.png (deflated 37%)\n",
      "  adding: image16.png (deflated 40%)\n",
      "  adding: image17.png (deflated 39%)\n",
      "  adding: image18.png (deflated 34%)\n",
      "  adding: image19.png (deflated 31%)\n",
      "  adding: image20.png (deflated 34%)\n",
      "  adding: image21.png (deflated 35%)\n",
      "  adding: image22.png (deflated 34%)\n",
      "  adding: image23.png (deflated 35%)\n",
      "  adding: image24.png (deflated 38%)\n",
      "  adding: image25.png (deflated 35%)\n",
      "  adding: image26.png (deflated 37%)\n",
      "  adding: image27.png (deflated 37%)\n",
      "  adding: image28.png (deflated 34%)\n",
      "  adding: image29.png (deflated 27%)\n",
      "  adding: image30.png (deflated 28%)\n",
      "  adding: image31.png (deflated 31%)\n",
      "  adding: image32.png (deflated 27%)\n",
      "  adding: image33.png (deflated 25%)\n",
      "  adding: image34.png (deflated 23%)\n",
      "  adding: image35.png (deflated 20%)\n",
      "  adding: image36.png (deflated 23%)\n",
      "  adding: image37.png (deflated 25%)\n",
      "  adding: image38.png (deflated 24%)\n",
      "  adding: image39.png (deflated 28%)\n",
      "  adding: image40.png (deflated 32%)\n",
      "  adding: image41.png (deflated 38%)\n",
      "  adding: image42.png (deflated 36%)\n",
      "  adding: image43.png (deflated 36%)\n",
      "  adding: image44.png (deflated 33%)\n",
      "  adding: image45.png (deflated 29%)\n",
      "  adding: image46.png (deflated 23%)\n",
      "  adding: image47.png (deflated 23%)\n",
      "  adding: image48.png (deflated 28%)\n",
      "  adding: image49.png (deflated 24%)\n",
      "  adding: image50.png (deflated 29%)\n",
      "  adding: image51.png (deflated 33%)\n",
      "  adding: image52.png (deflated 38%)\n",
      "  adding: image53.png (deflated 39%)\n",
      "  adding: image54.png (deflated 38%)\n",
      "  adding: image55.png (deflated 39%)\n",
      "  adding: image56.png (deflated 36%)\n",
      "  adding: image57.png (deflated 33%)\n",
      "  adding: image58.png (deflated 30%)\n",
      "  adding: image59.png (deflated 33%)\n",
      "  adding: image60.png (deflated 31%)\n",
      "  adding: image61.png (deflated 24%)\n",
      "  adding: image62.png (deflated 23%)\n",
      "  adding: image63.png (deflated 24%)\n",
      "  adding: image64.png (deflated 22%)\n",
      "  adding: image65.png (deflated 22%)\n",
      "  adding: image66.png (deflated 24%)\n",
      "  adding: image67.png (deflated 30%)\n",
      "  adding: image68.png (deflated 31%)\n",
      "  adding: image69.png (deflated 32%)\n",
      "  adding: image70.png (deflated 30%)\n",
      "  adding: image71.png (deflated 29%)\n",
      "  adding: image72.png (deflated 29%)\n",
      "  adding: image73.png (deflated 25%)\n",
      "  adding: image74.png (deflated 25%)\n",
      "  adding: image75.png (deflated 22%)\n",
      "  adding: image76.png (deflated 21%)\n",
      "  adding: image77.png (deflated 26%)\n",
      "  adding: image78.png (deflated 26%)\n",
      "  adding: image79.png (deflated 27%)\n",
      "  adding: image80.png (deflated 22%)\n",
      "  adding: image81.png (deflated 21%)\n",
      "  adding: image82.png (deflated 25%)\n",
      "  adding: image83.png (deflated 25%)\n",
      "  adding: image84.png (deflated 27%)\n",
      "  adding: image85.png (deflated 26%)\n",
      "  adding: image86.png (deflated 30%)\n",
      "  adding: image87.png (deflated 31%)\n",
      "  adding: image88.png (deflated 28%)\n",
      "  adding: image89.png (deflated 27%)\n",
      "  adding: image90.png (deflated 30%)\n",
      "  adding: image91.png (deflated 28%)\n",
      "  adding: image92.png (deflated 24%)\n",
      "  adding: image93.png (deflated 22%)\n",
      "  adding: image94.png (deflated 19%)\n",
      "  adding: image95.png (deflated 17%)\n",
      "  adding: image96.png (deflated 18%)\n",
      "  adding: image97.png (deflated 21%)\n",
      "  adding: image98.png (deflated 24%)\n",
      "  adding: image99.png (deflated 25%)\n"
     ]
    }
   ],
   "source": [
    "!zip images.zip image*.png\n",
    "!rm image*.png"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the constructed world\n",
    "\n",
    "Finally, using the `display_world` code from the `helpers.py` file (which was also used in the first notebook), we can actually visualize what you have coded with `slam`: the final position of the robot and the positon of landmarks, created from only motion and measurement data!\n",
    "\n",
    "**Note that these should be very similar to the printed *true* landmark locations and final pose from our call to `make_data` early in this notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  [ 68.84  14.44]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f525f8ca320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20,20)\n",
    "\n",
    "# check if poses has been created\n",
    "if 'lastpose' in locals():\n",
    "    # print out the last pose\n",
    "    print('Last pose: ', lastpose)\n",
    "    # display the last position of the robot *and* the landmark positions\n",
    "    my_display_world(int(world_size), lastpose, landmarks, save_file=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Omega and Xi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data viz resources\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f52622f5a58>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5262307b00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (12,7)\n",
    "\n",
    "omega, xi = myslam.get_omega_xi()\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(omega), cmap='Blues', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f5261dcc6d8>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5262722828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (3,7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(xi), cmap='Oranges', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
